The claimed invention relates to concurrent data processing and, more particularly, to concurrent data processing involving a shared resource.
For some time, computing environments have been available that support multithreading, which enables programs whose parts may execute concurrently. Such parts of a program that may execute independently of other parts are typically referred to as “threads.” Examples of computing environments that may support concurrent (e.g., parallel) execution of threads may include operating systems, compilers, virtual machines, run-time systems, and just-in-time (JIT) compilers.
In some situations, multiple threads may want to perform different operations on the same data element and/or data structure (i.e., a shared resource). To handle such instances, multithreaded computing environments typically include one or more synchronization mechanisms for synchronizing parallel activities of threads. One example of such a synchronization mechanism that may be provided (e.g., via an application programming interface (API) or other interface) is a “lock” that allows exclusive use of the shared resource for a certain time by a particular thread. In such a case, a thread may acquire a lock, perform one or more operations that need to be mutually exclusive, and release the lock after performing the operation(s). The computing environment may ensure that only one thread at a time can acquire a lock, regardless of other threads also trying to acquire a lock.
Such locking synchronization mechanisms, however, may require a substantial amount of overhead for associated system calls (e.g., for keeping track of which threads own which locks and/or the states of locks). This overhead may be large enough to impact performance if the locks are used in performance-critical code. Also, these locking mechanisms may not be tolerant of faults. For example, if a thread that has acquired a lock dies (e.g., is killed or exits abnormally) before releasing its lock, other threads may be prevented from accessing the shared resources protected by that unreleased lock. Further, if a thread that owns a lock is suspended, a “deadlock” may occur if the resumption of the suspended thread is dependent on the completion of another task whose progress, in turn, is dependent on the lock of the suspended thread.